package com.example.musicwebcon.service;


import com.example.musicwebcon.model.User;
import com.example.musicwebcon.model.UserInfo;
import com.example.musicwebcon.model.dto.UserDTO;
import com.example.musicwebcon.model.dto.UserInfoDTO;
import com.example.musicwebcon.repository.UserInfoRepository;
import com.example.musicwebcon.repository.UserRepository;
import com.example.musicwebcon.service.serviceInterface.IUserService;
import com.example.musicwebcon.util.IdGenerator;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;


import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Optional;

@Service
@Component
public class UserService implements IUserService {
    @Autowired
    UserRepository userRepository;
    @Autowired
    UserInfoService userInfoService;
    @Autowired
    private UserInfoRepository userInfoRepository;
    @Override
    public User add(UserDTO user){
        // 如果用户没有设置用户名，则使用昵称作为用户名
        if (user.getName() == null || user.getName().isEmpty()) {
            user.setName(user.getNickname());
        }
        // 如果未设置 ID，生成一个新的唯一 ID
        if (user.getId() == null || user.getId().isEmpty()) {
            user.setId(IdGenerator.generateUserId()); // 调用 ID 生成工具
        }
        // 检查用户名是否已存在
        if (userRepository.findByName(user.getName()).isPresent()) {
            throw new IllegalArgumentException("用户名已存在，请使用其他用户名");
        }
        if (userRepository.findByEmail(user.getEmail()).isPresent()) {
            throw new IllegalArgumentException("邮箱已被注册，请使用其他邮箱");
        }
        // 加密密码
        User userEntity = new User();
        BeanUtils.copyProperties(user, userEntity); // 将 UserDao 转换为 User 实体对象
        // 保存用户信息到数据库
        try {
            User savedUser = userRepository.save(userEntity); // 保存用户
            // 同步注册用户信息 (UserInfo)
            UserInfoDTO userInfoDTO = new UserInfoDTO();
            userInfoDTO.setInfoId(savedUser.getId());
            userInfoDTO.setNickname(savedUser.getNickname());
            userInfoDTO.setGender(savedUser.getGender());
            userInfoService.add(userInfoDTO); // 调用 UserInfoService 添加用户信息
            return savedUser;
        } catch (Exception e) {
            e.printStackTrace(); // 打印详细的错误信息
            throw new IllegalArgumentException("保存用户失败，请稍后重试");
        }
    }


    @Override
    public User get(String userId) {
        return userRepository.findById(userId).orElseThrow(() -> {
            throw new IllegalArgumentException("用户不存在，参数异常！");
        });
    }

    @Override
    public User edit(UserDTO user) {
//        User userEntity = new User();
//        BeanUtils.copyProperties(user, userEntity);
//
//        return userRepository.save(userEntity);
        // 检查用户是否存在
        User existingUser = userRepository.findById(user.getId())
                .orElseThrow(() -> new IllegalArgumentException("用户不存在，无法更新！"));

        // 更新 User 数据
        BeanUtils.copyProperties(user, existingUser, "password"); // 避免直接覆盖密码等敏感字段
        User updatedUser = userRepository.save(existingUser);

        // 查找并更新 UserInfo 数据
        UserInfo userInfo = userInfoRepository.findById(user.getId())
                .orElseThrow(() -> new IllegalArgumentException("用户信息不存在，无法更新！"));
        UserInfoDTO userInfoDTO = new UserInfoDTO();

        try {
            // 更新 UserInfo 数据
            userInfoDTO.setAvatar(userInfo.getAvatar());
            userInfoDTO.setInfoId(updatedUser.getId());
            userInfoDTO.setNickname(updatedUser.getNickname());
            userInfoDTO.setGender(updatedUser.getGender());
            // 其他的属性可以按需更新
            BeanUtils.copyProperties(userInfo, userInfoDTO); // 将 UserInfo 转换为 UserInfoDTO 对象
            userInfoService.edit(userInfoDTO); // 调用 UserInfoService 的 edit 方法
        } catch (Exception e) {
            e.printStackTrace();
            throw new IllegalArgumentException("用户信息更新失败，请稍后重试");
        }
        return updatedUser;
    }

    @Override
    public void delete(String userId) {
        userRepository.deleteById(userId);

        // 同步删除 UserInfo 数据
        try {
            userInfoService.delete(userId); // 调用 UserInfoService 的 delete 方法
        } catch (Exception e) {
            e.printStackTrace();
            throw new IllegalArgumentException("用户信息删除失败，请稍后重试");
        }
    }


    //自定义查询的
    public List<User> getUsersInAgeRange(Integer minAge, Integer maxAge) {
        if (minAge == null) {
            minAge = 0;
        }
        // 如果 maxAge 为空，则从 到最大值
        if (maxAge == null) {
            maxAge = 1000000000;
        }
        return userRepository.findByAgeBetween(minAge, maxAge);
    }

    @Override
    public User getByName(String userName) {
        Optional<User> userEntity = userRepository.findByName(userName);
        if (userEntity.isPresent()) {
            return userEntity.get();  // 如果用户存在，返回用户
        } else {
            throw new IllegalArgumentException("用户名不存在！");
        }
    }
    // 根据昵称模糊查询用户
    public List<User> getUsersByNickname(String nickname) {

        return userRepository.findByNicknameContaining(nickname);
    }

    @Override
    public User getByEmailAndPassword(String email, String password) {
        // 查询用户
        Optional<User> optionalUser = userRepository.findByEmail(email);
        // 判断用户是否存在
        if (optionalUser.isPresent()) {
            User user = optionalUser.get();
            if (password.equals(user.getPassword())) {
                return user; // 返回用户信息
            }
        }
        throw new IllegalArgumentException("邮箱或密码错误"); // 抛出错误提示
    }

    @Override
    public Optional<User> getUserByEmail(String email) {
        return userRepository.findByEmail(email);
    }
}
